import com.google.inject.*;

@Singleton
public class Main {
    // Guice creates an implicit Provider<T> for its injectables!  How nifty!
    private final Provider<Builder> builders;

    @Inject
    public Main(final Provider<Builder> builders) {
        this.builders = builders;
    }

    private void run() {
        final Builder builder = builder();

        System.out.println("Got builder " + builder);

        final Builder another = builder();

        System.out.println("Got another builder " + another);
    }

    public Builder builder() {
        return builders.get();
    }

    public static void main(final String... unused) {
        final Main main = Guice.createInjector(new Module()).getInstance(Main.class);

        main.run();
    }

    // NOOP module to demonstrate that Guice will do much of this for you—for better or for worse—
    // automagically.
    private static class Module extends AbstractModule {
        @Override
        protected void configure() {}
    }

    // Hard to know what happens with the scoping here.  Give it a try if you want to restrict one of
    // these suckers to a more constrained scope.
    private static class Builder {
        private final SingletonDependency singleton;

        @Inject
        public Builder(final SingletonDependency singleton) {
            this.singleton = singleton;
        }

        @Override
        public String toString() {
            return "Builder{" +
                    "singleton=" + singleton + " " +
                    "id=" + Integer.toHexString(System.identityHashCode(this)) +
                    '}';
        }
    }

    @Singleton
    public static class SingletonDependency {
        @Override
        public String toString() {
            return "SingletonDependency{" +
                    "id=" + Integer.toHexString(System.identityHashCode(this)) +
                    '}';
        }
    }

    // For your own tests …
    public static class ScopedDependency {
    }
}